home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / lib / python2.4 / test / test_codeccallbacks.pyc (.txt) < prev    next >
Python Compiled Bytecode  |  2005-10-18  |  21KB  |  560 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.4)
  3.  
  4. import test.test_support as test
  5. import unittest
  6. import sys
  7. import codecs
  8. import htmlentitydefs
  9. import unicodedata
  10.  
  11. class PosReturn:
  12.     
  13.     def __init__(self):
  14.         self.pos = 0
  15.  
  16.     
  17.     def handle(self, exc):
  18.         oldpos = self.pos
  19.         realpos = oldpos
  20.         if realpos < 0:
  21.             realpos = len(exc.object) + realpos
  22.         
  23.         if realpos <= exc.start:
  24.             self.pos = len(exc.object)
  25.         
  26.         return (u'<?>', oldpos)
  27.  
  28.  
  29.  
  30. class CodecCallbackTest(unittest.TestCase):
  31.     
  32.     def test_xmlcharrefreplace(self):
  33.         s = u'\xe3\x82\xb9\xe3\x83\x91\xe3\x83\xa2 \xc3\xa4nd eggs'
  34.         self.assertEqual(s.encode('ascii', 'xmlcharrefreplace'), 'スパモ änd eggs')
  35.         self.assertEqual(s.encode('latin-1', 'xmlcharrefreplace'), 'スパモ \xe4nd eggs')
  36.  
  37.     
  38.     def test_xmlcharnamereplace(self):
  39.         
  40.         def xmlcharnamereplace(exc):
  41.             if not isinstance(exc, UnicodeEncodeError):
  42.                 raise TypeError("don't know how to handle %r" % exc)
  43.             
  44.             l = []
  45.             for c in exc.object[exc.start:exc.end]:
  46.                 
  47.                 try:
  48.                     l.append(u'&%s;' % htmlentitydefs.codepoint2name[ord(c)])
  49.                 continue
  50.                 except KeyError:
  51.                     l.append(u'&#%d;' % ord(c))
  52.                     continue
  53.                 
  54.  
  55.             
  56.             return (u''.join(l), exc.end)
  57.  
  58.         codecs.register_error('test.xmlcharnamereplace', xmlcharnamereplace)
  59.         sin = u'\xc2\xab\xe2\x84\x9c\xc2\xbb = \xe2\x8c\xa9\xe1\x88\xb4\xe2\x82\xac\xe2\x8c\xaa'
  60.         sout = '«ℜ» = ⟨ሴ€⟩'
  61.         self.assertEqual(sin.encode('ascii', 'test.xmlcharnamereplace'), sout)
  62.         sout = '\xabℜ\xbb = ⟨ሴ€⟩'
  63.         self.assertEqual(sin.encode('latin-1', 'test.xmlcharnamereplace'), sout)
  64.         sout = '\xabℜ\xbb = ⟨ሴ\xa4⟩'
  65.         self.assertEqual(sin.encode('iso-8859-15', 'test.xmlcharnamereplace'), sout)
  66.  
  67.     
  68.     def test_uninamereplace(self):
  69.         
  70.         def uninamereplace(exc):
  71.             if not isinstance(exc, UnicodeEncodeError):
  72.                 raise TypeError("don't know how to handle %r" % exc)
  73.             
  74.             l = []
  75.             for c in exc.object[exc.start:exc.end]:
  76.                 l.append(unicodedata.name(c, u'0x%x' % ord(c)))
  77.             
  78.             return (u'\x1b[1m%s\x1b[0m' % u', '.join(l), exc.end)
  79.  
  80.         codecs.register_error('test.uninamereplace', uninamereplace)
  81.         sin = u'\xc2\xac\xe1\x88\xb4\xe2\x82\xac\xe8\x80\x80'
  82.         sout = '\x1b[1mNOT SIGN, ETHIOPIC SYLLABLE SEE, EURO SIGN, CJK UNIFIED IDEOGRAPH-8000\x1b[0m'
  83.         self.assertEqual(sin.encode('ascii', 'test.uninamereplace'), sout)
  84.         sout = '\xac\x1b[1mETHIOPIC SYLLABLE SEE, EURO SIGN, CJK UNIFIED IDEOGRAPH-8000\x1b[0m'
  85.         self.assertEqual(sin.encode('latin-1', 'test.uninamereplace'), sout)
  86.         sout = '\xac\x1b[1mETHIOPIC SYLLABLE SEE\x1b[0m\xa4\x1b[1mCJK UNIFIED IDEOGRAPH-8000\x1b[0m'
  87.         self.assertEqual(sin.encode('iso-8859-15', 'test.uninamereplace'), sout)
  88.  
  89.     
  90.     def test_backslashescape(self):
  91.         sin = u'a\xc2\xac\xe1\x88\xb4\xe2\x82\xac\xe8\x80\x80'
  92.         if sys.maxunicode > 65535:
  93.             sin += unichr(sys.maxunicode)
  94.         
  95.         sout = 'a\\xac\\u1234\\u20ac\\u8000'
  96.         if sys.maxunicode > 65535:
  97.             sout += '\\U%08x' % sys.maxunicode
  98.         
  99.         self.assertEqual(sin.encode('ascii', 'backslashreplace'), sout)
  100.         sout = 'a\xac\\u1234\\u20ac\\u8000'
  101.         if sys.maxunicode > 65535:
  102.             sout += '\\U%08x' % sys.maxunicode
  103.         
  104.         self.assertEqual(sin.encode('latin-1', 'backslashreplace'), sout)
  105.         sout = 'a\xac\\u1234\xa4\\u8000'
  106.         if sys.maxunicode > 65535:
  107.             sout += '\\U%08x' % sys.maxunicode
  108.         
  109.         self.assertEqual(sin.encode('iso-8859-15', 'backslashreplace'), sout)
  110.  
  111.     
  112.     def test_decoderelaxedutf8(self):
  113.         
  114.         def relaxedutf8(exc):
  115.             if not isinstance(exc, UnicodeDecodeError):
  116.                 raise TypeError("don't know how to handle %r" % exc)
  117.             
  118.             if exc.object[exc.start:exc.end].startswith('\xc0\x80'):
  119.                 return (u'\x00', exc.start + 2)
  120.             else:
  121.                 raise exc
  122.  
  123.         codecs.register_error('test.relaxedutf8', relaxedutf8)
  124.         sin = 'a\x00b\xc0\x80c\xc3\xbc\xc0\x80\xc0\x80'
  125.         sout = u'a\x00b\x00c\xc3\xbc\x00\x00'
  126.         self.assertEqual(sin.decode('utf-8', 'test.relaxedutf8'), sout)
  127.         sin = '\xc0\x80\xc0\x81'
  128.         self.assertRaises(UnicodeError, sin.decode, 'utf-8', 'test.relaxedutf8')
  129.  
  130.     
  131.     def test_charmapencode(self):
  132.         charmap = []([ (ord(c), 2 * c.upper()) for c in 'abcdefgh' ])
  133.         sin = u'abc'
  134.         sout = 'AABBCC'
  135.         self.assertEquals(codecs.charmap_encode(sin, 'strict', charmap)[0], sout)
  136.         sin = u'abcA'
  137.         self.assertRaises(UnicodeError, codecs.charmap_encode, sin, 'strict', charmap)
  138.         charmap[ord('?')] = 'XYZ'
  139.         sin = u'abcDEF'
  140.         sout = 'AABBCCXYZXYZXYZ'
  141.         self.assertEquals(codecs.charmap_encode(sin, 'replace', charmap)[0], sout)
  142.         charmap[ord('?')] = u'XYZ'
  143.         self.assertRaises(TypeError, codecs.charmap_encode, sin, 'replace', charmap)
  144.         charmap[ord('?')] = u'XYZ'
  145.         self.assertRaises(TypeError, codecs.charmap_encode, sin, 'replace', charmap)
  146.  
  147.     
  148.     def test_decodeunicodeinternal(self):
  149.         self.assertRaises(UnicodeDecodeError, '\x00\x00\x00\x00\x00'.decode, 'unicode-internal')
  150.         if sys.maxunicode > 65535:
  151.             
  152.             def handler_unicodeinternal(exc):
  153.                 if not isinstance(exc, UnicodeDecodeError):
  154.                     raise TypeError("don't know how to handle %r" % exc)
  155.                 
  156.                 return (u'\x01', 1)
  157.  
  158.             self.assertEqual('\x00\x00\x00\x00\x00'.decode('unicode-internal', 'ignore'), u'\x00')
  159.             self.assertEqual('\x00\x00\x00\x00\x00'.decode('unicode-internal', 'replace'), u'\x00\xef\xbf\xbd')
  160.             codecs.register_error('test.hui', handler_unicodeinternal)
  161.             self.assertEqual('\x00\x00\x00\x00\x00'.decode('unicode-internal', 'test.hui'), u'\x00\x01\x00')
  162.         
  163.  
  164.     
  165.     def test_callbacks(self):
  166.         
  167.         def handler1(exc):
  168.             if not isinstance(exc, UnicodeEncodeError) and not isinstance(exc, UnicodeDecodeError):
  169.                 raise TypeError("don't know how to handle %r" % exc)
  170.             
  171.             l = [ u'<%d>' % ord(exc.object[pos]) for pos in xrange(exc.start, exc.end) ]
  172.             return (u'[%s]' % u''.join(l), exc.end)
  173.  
  174.         codecs.register_error('test.handler1', handler1)
  175.         
  176.         def handler2(exc):
  177.             if not isinstance(exc, UnicodeDecodeError):
  178.                 raise TypeError("don't know how to handle %r" % exc)
  179.             
  180.             l = [ u'<%d>' % ord(exc.object[pos]) for pos in xrange(exc.start, exc.end) ]
  181.             return (u'[%s]' % u''.join(l), exc.end + 1)
  182.  
  183.         codecs.register_error('test.handler2', handler2)
  184.         s = '\x00\x81\x7f\x80\xff'
  185.         self.assertEqual(s.decode('ascii', 'test.handler1'), u'\x00[<129>]\x7f[<128>][<255>]')
  186.         self.assertEqual(s.decode('ascii', 'test.handler2'), u'\x00[<129>][<128>]')
  187.         self.assertEqual('\\u3042\\u3xxx'.decode('unicode-escape', 'test.handler1'), u'\xe3\x81\x82[<92><117><51><120>]xx')
  188.         self.assertEqual('\\u3042\\u3xx'.decode('unicode-escape', 'test.handler1'), u'\xe3\x81\x82[<92><117><51><120><120>]')
  189.         self.assertEqual(codecs.charmap_decode('abc', 'test.handler1', {
  190.             ord('a'): u'z' })[0], u'z[<98>][<99>]')
  191.         self.assertEqual(u'g\xc3\xbc\xc3\x9frk'.encode('ascii', 'test.handler1'), u'g[<252><223>]rk')
  192.         self.assertEqual(u'g\xc3\xbc\xc3\x9f'.encode('ascii', 'test.handler1'), u'g[<252><223>]')
  193.  
  194.     
  195.     def test_longstrings(self):
  196.         errors = [
  197.             'strict',
  198.             'ignore',
  199.             'replace',
  200.             'xmlcharrefreplace',
  201.             'backslashreplace']
  202.         for err in errors:
  203.             codecs.register_error('test.' + err, codecs.lookup_error(err))
  204.         
  205.         l = 1000
  206.         [] += [ 'test.' + err for err in errors ]
  207.         for s in (u'x', u'\xe3\x81\x82', u'a\xc3\xa4'):
  208.             pass
  209.         
  210.  
  211.     
  212.     def check_exceptionobjectargs(self, exctype, args, msg):
  213.         self.assertRaises(TypeError, exctype, *args[:-1])
  214.         self.assertRaises(TypeError, exctype, *args + [
  215.             'too much'])
  216.         wrongargs = [
  217.             'spam',
  218.             u'eggs',
  219.             42,
  220.             1.0,
  221.             None]
  222.         for i in xrange(len(args)):
  223.             for wrongarg in wrongargs:
  224.                 if type(wrongarg) is type(args[i]):
  225.                     continue
  226.                 
  227.                 callargs = []
  228.                 for j in xrange(len(args)):
  229.                     if i == j:
  230.                         callargs.append(wrongarg)
  231.                         continue
  232.                     callargs.append(args[i])
  233.                 
  234.                 self.assertRaises(TypeError, exctype, *callargs)
  235.             
  236.         
  237.         exc = exctype(*args)
  238.         self.assertEquals(str(exc), msg)
  239.  
  240.     
  241.     def test_unicodeencodeerror(self):
  242.         self.check_exceptionobjectargs(UnicodeEncodeError, [
  243.             'ascii',
  244.             u'g\xc3\xbcrk',
  245.             1,
  246.             2,
  247.             'ouch'], "'ascii' codec can't encode character u'\\xfc' in position 1: ouch")
  248.         self.check_exceptionobjectargs(UnicodeEncodeError, [
  249.             'ascii',
  250.             u'g\xc3\xbcrk',
  251.             1,
  252.             4,
  253.             'ouch'], "'ascii' codec can't encode characters in position 1-3: ouch")
  254.         self.check_exceptionobjectargs(UnicodeEncodeError, [
  255.             'ascii',
  256.             u'\xc3\xbcx',
  257.             0,
  258.             1,
  259.             'ouch'], "'ascii' codec can't encode character u'\\xfc' in position 0: ouch")
  260.         self.check_exceptionobjectargs(UnicodeEncodeError, [
  261.             'ascii',
  262.             u'\xc4\x80x',
  263.             0,
  264.             1,
  265.             'ouch'], "'ascii' codec can't encode character u'\\u0100' in position 0: ouch")
  266.         self.check_exceptionobjectargs(UnicodeEncodeError, [
  267.             'ascii',
  268.             u'\xef\xbf\xbfx',
  269.             0,
  270.             1,
  271.             'ouch'], "'ascii' codec can't encode character u'\\uffff' in position 0: ouch")
  272.         if sys.maxunicode > 65535:
  273.             self.check_exceptionobjectargs(UnicodeEncodeError, [
  274.                 'ascii',
  275.                 u'\xf0\x90\x80\x80x',
  276.                 0,
  277.                 1,
  278.                 'ouch'], "'ascii' codec can't encode character u'\\U00010000' in position 0: ouch")
  279.         
  280.  
  281.     
  282.     def test_unicodedecodeerror(self):
  283.         self.check_exceptionobjectargs(UnicodeDecodeError, [
  284.             'ascii',
  285.             'g\xfcrk',
  286.             1,
  287.             2,
  288.             'ouch'], "'ascii' codec can't decode byte 0xfc in position 1: ouch")
  289.         self.check_exceptionobjectargs(UnicodeDecodeError, [
  290.             'ascii',
  291.             'g\xfcrk',
  292.             1,
  293.             3,
  294.             'ouch'], "'ascii' codec can't decode bytes in position 1-2: ouch")
  295.  
  296.     
  297.     def test_unicodetranslateerror(self):
  298.         self.check_exceptionobjectargs(UnicodeTranslateError, [
  299.             u'g\xc3\xbcrk',
  300.             1,
  301.             2,
  302.             'ouch'], "can't translate character u'\\xfc' in position 1: ouch")
  303.         self.check_exceptionobjectargs(UnicodeTranslateError, [
  304.             u'g\xc4\x80rk',
  305.             1,
  306.             2,
  307.             'ouch'], "can't translate character u'\\u0100' in position 1: ouch")
  308.         self.check_exceptionobjectargs(UnicodeTranslateError, [
  309.             u'g\xef\xbf\xbfrk',
  310.             1,
  311.             2,
  312.             'ouch'], "can't translate character u'\\uffff' in position 1: ouch")
  313.         if sys.maxunicode > 65535:
  314.             self.check_exceptionobjectargs(UnicodeTranslateError, [
  315.                 u'g\xf0\x90\x80\x80rk',
  316.                 1,
  317.                 2,
  318.                 'ouch'], "can't translate character u'\\U00010000' in position 1: ouch")
  319.         
  320.         self.check_exceptionobjectargs(UnicodeTranslateError, [
  321.             u'g\xc3\xbcrk',
  322.             1,
  323.             3,
  324.             'ouch'], "can't translate characters in position 1-2: ouch")
  325.  
  326.     
  327.     def test_badandgoodstrictexceptions(self):
  328.         self.assertRaises(TypeError, codecs.strict_errors, 42)
  329.         self.assertRaises(Exception, codecs.strict_errors, Exception('ouch'))
  330.         self.assertRaises(UnicodeEncodeError, codecs.strict_errors, UnicodeEncodeError('ascii', u'\xe3\x81\x82', 0, 1, 'ouch'))
  331.  
  332.     
  333.     def test_badandgoodignoreexceptions(self):
  334.         self.assertRaises(TypeError, codecs.ignore_errors, 42)
  335.         self.assertRaises(TypeError, codecs.ignore_errors, UnicodeError('ouch'))
  336.         self.assertEquals(codecs.ignore_errors(UnicodeEncodeError('ascii', u'\xe3\x81\x82', 0, 1, 'ouch')), (u'', 1))
  337.         self.assertEquals(codecs.ignore_errors(UnicodeDecodeError('ascii', '\xff', 0, 1, 'ouch')), (u'', 1))
  338.         self.assertEquals(codecs.ignore_errors(UnicodeTranslateError(u'\xe3\x81\x82', 0, 1, 'ouch')), (u'', 1))
  339.  
  340.     
  341.     def test_badandgoodreplaceexceptions(self):
  342.         self.assertRaises(TypeError, codecs.replace_errors, 42)
  343.         self.assertRaises(TypeError, codecs.replace_errors, UnicodeError('ouch'))
  344.         self.assertEquals(codecs.replace_errors(UnicodeEncodeError('ascii', u'\xe3\x81\x82', 0, 1, 'ouch')), (u'?', 1))
  345.         self.assertEquals(codecs.replace_errors(UnicodeDecodeError('ascii', '\xff', 0, 1, 'ouch')), (u'\xef\xbf\xbd', 1))
  346.         self.assertEquals(codecs.replace_errors(UnicodeTranslateError(u'\xe3\x81\x82', 0, 1, 'ouch')), (u'\xef\xbf\xbd', 1))
  347.  
  348.     
  349.     def test_badandgoodxmlcharrefreplaceexceptions(self):
  350.         self.assertRaises(TypeError, codecs.xmlcharrefreplace_errors, 42)
  351.         self.assertRaises(TypeError, codecs.xmlcharrefreplace_errors, UnicodeError('ouch'))
  352.         self.assertRaises(TypeError, codecs.xmlcharrefreplace_errors, UnicodeDecodeError('ascii', '\xff', 0, 1, 'ouch'))
  353.         self.assertRaises(TypeError, codecs.xmlcharrefreplace_errors, UnicodeTranslateError(u'\xe3\x81\x82', 0, 1, 'ouch'))
  354.         self.assertEquals(codecs.xmlcharrefreplace_errors(UnicodeEncodeError('ascii', u'\xe3\x81\x82', 0, 1, 'ouch')), (u'&#%d;' % 12354, 1))
  355.  
  356.     
  357.     def test_badandgoodbackslashreplaceexceptions(self):
  358.         self.assertRaises(TypeError, codecs.backslashreplace_errors, 42)
  359.         self.assertRaises(TypeError, codecs.backslashreplace_errors, UnicodeError('ouch'))
  360.         self.assertRaises(TypeError, codecs.backslashreplace_errors, UnicodeDecodeError('ascii', '\xff', 0, 1, 'ouch'))
  361.         self.assertRaises(TypeError, codecs.backslashreplace_errors, UnicodeTranslateError(u'\xe3\x81\x82', 0, 1, 'ouch'))
  362.         self.assertEquals(codecs.backslashreplace_errors(UnicodeEncodeError('ascii', u'\xe3\x81\x82', 0, 1, 'ouch')), (u'\\u3042', 1))
  363.         self.assertEquals(codecs.backslashreplace_errors(UnicodeEncodeError('ascii', u'\x00', 0, 1, 'ouch')), (u'\\x00', 1))
  364.         self.assertEquals(codecs.backslashreplace_errors(UnicodeEncodeError('ascii', u'\xc3\xbf', 0, 1, 'ouch')), (u'\\xff', 1))
  365.         self.assertEquals(codecs.backslashreplace_errors(UnicodeEncodeError('ascii', u'\xc4\x80', 0, 1, 'ouch')), (u'\\u0100', 1))
  366.         self.assertEquals(codecs.backslashreplace_errors(UnicodeEncodeError('ascii', u'\xef\xbf\xbf', 0, 1, 'ouch')), (u'\\uffff', 1))
  367.         if sys.maxunicode > 65535:
  368.             self.assertEquals(codecs.backslashreplace_errors(UnicodeEncodeError('ascii', u'\xf0\x90\x80\x80', 0, 1, 'ouch')), (u'\\U00010000', 1))
  369.             self.assertEquals(codecs.backslashreplace_errors(UnicodeEncodeError('ascii', u'\xf4\x8f\xbf\xbf', 0, 1, 'ouch')), (u'\\U0010ffff', 1))
  370.         
  371.  
  372.     
  373.     def test_badhandlerresults(self):
  374.         results = (42, u'foo', (1, 2, 3), (u'foo', 1, 3), (u'foo', None), (u'foo',), ('foo', 1, 3), ('foo', None), ('foo',))
  375.         encs = ('ascii', 'latin-1', 'iso-8859-1', 'iso-8859-15')
  376.         for None in results:
  377.             res = None
  378.             for enc in encs:
  379.                 self.assertRaises(TypeError, u'\xe3\x81\x82'.encode, enc, 'test.badhandler')
  380.             
  381.             for enc, bytes in (('ascii', '\xff'), ('utf-8', '\xff'), ('utf-7', '+x-'), ('unicode-internal', '\x00')):
  382.                 self.assertRaises(TypeError, bytes.decode, enc, 'test.badhandler')
  383.             
  384.         
  385.  
  386.     
  387.     def test_lookup(self):
  388.         self.assertEquals(codecs.strict_errors, codecs.lookup_error('strict'))
  389.         self.assertEquals(codecs.ignore_errors, codecs.lookup_error('ignore'))
  390.         self.assertEquals(codecs.strict_errors, codecs.lookup_error('strict'))
  391.         self.assertEquals(codecs.xmlcharrefreplace_errors, codecs.lookup_error('xmlcharrefreplace'))
  392.         self.assertEquals(codecs.backslashreplace_errors, codecs.lookup_error('backslashreplace'))
  393.  
  394.     
  395.     def test_unencodablereplacement(self):
  396.         
  397.         def unencrepl(exc):
  398.             if isinstance(exc, UnicodeEncodeError):
  399.                 return (u'\xe4\x89\x82', exc.end)
  400.             else:
  401.                 raise TypeError("don't know how to handle %r" % exc)
  402.  
  403.         codecs.register_error('test.unencreplhandler', unencrepl)
  404.         for enc in ('ascii', 'iso-8859-1', 'iso-8859-15'):
  405.             self.assertRaises(UnicodeEncodeError, u'\xe4\x89\x82'.encode, enc, 'test.unencreplhandler')
  406.         
  407.  
  408.     
  409.     def test_badregistercall(self):
  410.         self.assertRaises(TypeError, codecs.register_error, 42)
  411.         self.assertRaises(TypeError, codecs.register_error, 'test.dummy', 42)
  412.  
  413.     
  414.     def test_unknownhandler(self):
  415.         self.assertRaises(LookupError, codecs.lookup_error, 'test.unknown')
  416.  
  417.     
  418.     def test_xmlcharrefvalues(self):
  419.         v = (1, 5, 10, 50, 100, 500, 1000, 5000, 10000, 50000)
  420.         if sys.maxunicode >= 100000:
  421.             v += (100000, 500000, 1000000)
  422.         
  423.         s = []([ unichr(x) for x in v ])
  424.         codecs.register_error('test.xmlcharrefreplace', codecs.xmlcharrefreplace_errors)
  425.         for enc in ('ascii', 'iso-8859-15'):
  426.             for err in ('xmlcharrefreplace', 'test.xmlcharrefreplace'):
  427.                 s.encode(enc, err)
  428.             
  429.         
  430.  
  431.     
  432.     def test_decodehelper(self):
  433.         self.assertRaises(LookupError, '\xff'.decode, 'ascii', 'test.unknown')
  434.         
  435.         def baddecodereturn1(exc):
  436.             return 42
  437.  
  438.         codecs.register_error('test.baddecodereturn1', baddecodereturn1)
  439.         self.assertRaises(TypeError, '\xff'.decode, 'ascii', 'test.baddecodereturn1')
  440.         self.assertRaises(TypeError, '\\'.decode, 'unicode-escape', 'test.baddecodereturn1')
  441.         self.assertRaises(TypeError, '\\x0'.decode, 'unicode-escape', 'test.baddecodereturn1')
  442.         self.assertRaises(TypeError, '\\x0y'.decode, 'unicode-escape', 'test.baddecodereturn1')
  443.         self.assertRaises(TypeError, '\\Uffffeeee'.decode, 'unicode-escape', 'test.baddecodereturn1')
  444.         self.assertRaises(TypeError, '\\uyyyy'.decode, 'raw-unicode-escape', 'test.baddecodereturn1')
  445.         
  446.         def baddecodereturn2(exc):
  447.             return (u'?', None)
  448.  
  449.         codecs.register_error('test.baddecodereturn2', baddecodereturn2)
  450.         self.assertRaises(TypeError, '\xff'.decode, 'ascii', 'test.baddecodereturn2')
  451.         handler = PosReturn()
  452.         codecs.register_error('test.posreturn', handler.handle)
  453.         handler.pos = -1
  454.         self.assertEquals('\xff0'.decode('ascii', 'test.posreturn'), u'<?>0')
  455.         handler.pos = -2
  456.         self.assertEquals('\xff0'.decode('ascii', 'test.posreturn'), u'<?><?>')
  457.         handler.pos = -3
  458.         self.assertRaises(IndexError, '\xff0'.decode, 'ascii', 'test.posreturn')
  459.         handler.pos = 1
  460.         self.assertEquals('\xff0'.decode('ascii', 'test.posreturn'), u'<?>0')
  461.         handler.pos = 2
  462.         self.assertEquals('\xff0'.decode('ascii', 'test.posreturn'), u'<?>')
  463.         handler.pos = 3
  464.         self.assertRaises(IndexError, '\xff0'.decode, 'ascii', 'test.posreturn')
  465.         handler.pos = 6
  466.         self.assertEquals('\\uyyyy0'.decode('raw-unicode-escape', 'test.posreturn'), u'<?>0')
  467.         
  468.         class D(dict):
  469.             
  470.             def __getitem__(self, key):
  471.                 raise ValueError
  472.  
  473.  
  474.         self.assertRaises(UnicodeError, codecs.charmap_decode, '\xff', 'strict', {
  475.             255: None })
  476.         self.assertRaises(ValueError, codecs.charmap_decode, '\xff', 'strict', D())
  477.         self.assertRaises(TypeError, codecs.charmap_decode, '\xff', 'strict', {
  478.             255: sys.maxunicode + 1 })
  479.  
  480.     
  481.     def test_encodehelper(self):
  482.         self.assertRaises(LookupError, u'\xc3\xbf'.encode, 'ascii', 'test.unknown')
  483.         
  484.         def badencodereturn1(exc):
  485.             return 42
  486.  
  487.         codecs.register_error('test.badencodereturn1', badencodereturn1)
  488.         self.assertRaises(TypeError, u'\xc3\xbf'.encode, 'ascii', 'test.badencodereturn1')
  489.         
  490.         def badencodereturn2(exc):
  491.             return (u'?', None)
  492.  
  493.         codecs.register_error('test.badencodereturn2', badencodereturn2)
  494.         self.assertRaises(TypeError, u'\xc3\xbf'.encode, 'ascii', 'test.badencodereturn2')
  495.         handler = PosReturn()
  496.         codecs.register_error('test.posreturn', handler.handle)
  497.         handler.pos = -1
  498.         self.assertEquals(u'\xc3\xbf0'.encode('ascii', 'test.posreturn'), '<?>0')
  499.         handler.pos = -2
  500.         self.assertEquals(u'\xc3\xbf0'.encode('ascii', 'test.posreturn'), '<?><?>')
  501.         handler.pos = -3
  502.         self.assertRaises(IndexError, u'\xc3\xbf0'.encode, 'ascii', 'test.posreturn')
  503.         handler.pos = 1
  504.         self.assertEquals(u'\xc3\xbf0'.encode('ascii', 'test.posreturn'), '<?>0')
  505.         handler.pos = 2
  506.         self.assertEquals(u'\xc3\xbf0'.encode('ascii', 'test.posreturn'), '<?>')
  507.         handler.pos = 3
  508.         self.assertRaises(IndexError, u'\xc3\xbf0'.encode, 'ascii', 'test.posreturn')
  509.         handler.pos = 0
  510.         
  511.         class D(dict):
  512.             
  513.             def __getitem__(self, key):
  514.                 raise ValueError
  515.  
  516.  
  517.         for err in ('strict', 'replace', 'xmlcharrefreplace', 'backslashreplace', 'test.posreturn'):
  518.             self.assertRaises(UnicodeError, codecs.charmap_encode, u'\xc3\xbf', err, {
  519.                 255: None })
  520.             self.assertRaises(ValueError, codecs.charmap_encode, u'\xc3\xbf', err, D())
  521.             self.assertRaises(TypeError, codecs.charmap_encode, u'\xc3\xbf', err, {
  522.                 255: 300 })
  523.         
  524.  
  525.     
  526.     def test_translatehelper(self):
  527.         
  528.         class D(dict):
  529.             
  530.             def __getitem__(self, key):
  531.                 raise ValueError
  532.  
  533.  
  534.         self.assertRaises(ValueError, u'\xc3\xbf'.translate, D())
  535.         self.assertRaises(TypeError, u'\xc3\xbf'.translate, {
  536.             255: sys.maxunicode + 1 })
  537.         self.assertRaises(TypeError, u'\xc3\xbf'.translate, {
  538.             255: () })
  539.  
  540.     
  541.     def test_bug828737(self):
  542.         charmap = {
  543.             ord('&'): u'&',
  544.             ord('<'): u'<',
  545.             ord('>'): u'>',
  546.             ord('"'): u'"' }
  547.         for n in (1, 10, 100, 1000):
  548.             text = u'abc<def>ghi' * n
  549.             text.translate(charmap)
  550.         
  551.  
  552.  
  553.  
  554. def test_main():
  555.     test.test_support.run_unittest(CodecCallbackTest)
  556.  
  557. if __name__ == '__main__':
  558.     test_main()
  559.  
  560.